3 research outputs found
Heap Abstractions for Static Analysis
Heap data is potentially unbounded and seemingly arbitrary. As a consequence,
unlike stack and static memory, heap memory cannot be abstracted directly in
terms of a fixed set of source variable names appearing in the program being
analysed. This makes it an interesting topic of study and there is an abundance
of literature employing heap abstractions. Although most studies have addressed
similar concerns, their formulations and formalisms often seem dissimilar and
some times even unrelated. Thus, the insights gained in one description of heap
abstraction may not directly carry over to some other description. This survey
is a result of our quest for a unifying theme in the existing descriptions of
heap abstractions. In particular, our interest lies in the abstractions and not
in the algorithms that construct them.
In our search of a unified theme, we view a heap abstraction as consisting of
two features: a heap model to represent the heap memory and a summarization
technique for bounding the heap representation. We classify the models as
storeless, store based, and hybrid. We describe various summarization
techniques based on k-limiting, allocation sites, patterns, variables, other
generic instrumentation predicates, and higher-order logics. This approach
allows us to compare the insights of a large number of seemingly dissimilar
heap abstractions and also paves way for creating new abstractions by
mix-and-match of models and summarization techniques.Comment: 49 pages, 20 figure
Handling Communication via APIs for Microservices
Enterprises in their journey to the cloud, want to decompose their monolith
applications into microservices to maximize cloud benefits. Current research
focuses a lot on how to partition the monolith into smaller clusters that
perform well across standard metrics like coupling, cohesion, etc. However,
there is little research done on taking the partitions, identifying their
dependencies between the microservices, exploring ways to further reduce the
dependencies, and making appropriate code changes to enable robust
communication without modifying the application behaviour.
In this work, we discuss the challenges with the conventional techniques of
communication using JSON and propose an alternative way of ID-passing via APIs.
We also devise an algorithm to reduce the number of APIs. For this, we
construct subgraphs of methods and their associated variables in each class and
relocate them to their more functionally aligned microservices. Our
quantitative and qualitative studies on five public Java applications clearly
demonstrate that our refactored microservices using ID have decidedly better
time and memory complexities than JSON. Our automation reduces 40-60\% of the
manual refactoring efforts.Comment: 15 page